package Gramatica;

/*------------------------------------------------------------------------------
Regras
------------------------------------------------------------------------------
<x>     -   nao terminais
{x}     -   terminais
 e      -   vazio
 $      -   seguinte do nao-terminal inicial
-------------------------------------------------------------------------------
                                GRAMATICA
-------------------------------------------------------------------------------
                    - Conjunto primeiro e seguinte
-------------------------------------------------------------------------------
Blocos
-------------------------------------------------------------------------------
 
            -------------------Conjunto Primeiro---------------
P<programa> = P<diretivas>-e U P<decls_inicial>-e U {void}
P<diretivas> = e U {include}
P<decls_inicial> = e U P<typedef> U P<const> U P<prototipo> U P<declaracao>
P<corpo_funcao> = {
P<decls_final> = e U P<funcao>


            -------------------Conjunto Seguinte---------------
S<programa> = {$}
S<diretivas> = P<decls_inicial>-e U S<decls_inicial>
S<decls_inicial> = {void}
S<corpo_funcao>  = P<decls_final>-e U S<decls_final> U S<funcao>U P<decls_inicial>
S<decls_final> = S<programa>


-------------------------------------------------------------------------------
Declaracoes iniciais
-------------------------------------------------------------------------------
 
         -------------------Conjunto Primeiro---------------
 P<typedef> = {typedef}
 P<const> = {const}
 P<prototipo> = P<tipo>
    ->P<prototipo> = {'identificador', 'void', 'char', 'int', 'float', 'boolean' }
 P(declaracao) = P(declaracao_var) U P(declaracao_struct)
    ->P(declaracao) = { 'char', 'int', 'float', 'boolean', identificador }
 
        -------------------Conjunto Seguinte---------------
 S<typedef> = S<decls_inicial>
 S<const> = S<decls_inicial>
 S(prototipo) = P(corpo_funcao) U { ';' }
 S<declaracao> = S<decls_inicial> U P<typedef> U P<const> U P<prototipo> U P<declaracao> U {}} U S<instrucao>
        -> S<declaracao> = {void, typedef, const, 'identificador','char', 'int', 'float', 'boolean',
            if, while, do, return, for, printf,scanf,*, '}', 'else'}

-------------------------------------------------------------------------------
Funcao
-------------------------------------------------------------------------------
     -------------------Conjunto Primeiro---------------
P<funcao> = P<prototipo>
    ->P<funcao> = { 'identificador', 'void', 'char', 'int', 'float', 'boolean' }
P<chamada_funcao> = { identificador }
P<args_chamada> = P<expressao>
P<args_declaracao> = P<tipo_primitivo> U { identificador }

        -------------------Conjunto Seguinte---------------

 S<funcao> = S<decls_final> U P<funcao>
 S<chamada_funcao> = { ; }
 S<args_chamada> = {) }
 S<args_declaracao> = { ) }

-------------------------------------------------------------------------------
Tipos
-------------------------------------------------------------------------------

  -------------------Conjunto Primeiro---------------
 
 P<tipo> = {identificador, void } U P<tipo_primitivo>
    ->P<tipo> = { 'identificador', 'void', 'char', 'int', 'float', 'boolean' }
 P<tipo_primitivo> = {char, int, float, boolean}
 P<struct> = {struct}

  -------------------Conjunto Seguinte---------------

 S<tipo> = {"identificador"}
 S<tipo_primitivo> =  {identificador, *, ) }  U S<tipo>
    ->S<tipo_primitivo> ={"identificador", "*" , ")" )
 S<struct> = {"identificador"}


-------------------------------------------------------------------------------
Declaracoes
-------------------------------------------------------------------------------

                 -------------------Conjunto Primeiro---------------

P<declaracao_var> = P(tipo_primitivo)
    ->P<declaracao_var>= { 'char', 'int', 'float', 'boolean' }
P<atribuicao_var> =  {=}
P<array> = {[}
P<atribuicao_array> = {=}
P<declaracao_struct> = {'identificador'}


                -------------------Conjunto Seguinte--------------

 S<declaracao_var> =  S<declaracao>
 S<atribuicao_var> = {"," ";"}
 S<array> = {"," ";"}
 S<atribuicao_array> = S<array>
        ->S<atribuicao_array> = {"," ";"}
 S<declaracao_struct> = S<declaracao>

-------------------------------------------------------------------------------
Comandos
-------------------------------------------------------------------------------
 
                    -------------------Conjunto Primeiro---------------

P(cmd) = P(if) U P(while) U P(do_while) U P(return) U P(for) U P(printf) U P(scanf)
P(if) = {'if'}
P(while) = {'while'}
P(do_while) = {'do'}
P(return) = {'return'}
P(for) = {'for'}
P(printf) = {'printf'}
P(scanf) = {'scanf'}
P(bloco)= P(instrucao) U { "{" }
P(instrucao) = P(declaracao) U P(cmd) U P(atribuicao) U P(incremento) U P(chamada_funcao)
      ->P(instrucao) = { char, int, float, boolean, identificador, if, while, do, return, for, printf,scanf,*}

                  -------------------Conjunto Seguinte--------------

S(cmd) = S(instrucao)
S(if) = S(cmd)
S(while) = S(cmd)
S(for) = S(cmd)
S(bloco)= S(if) U S(for) U S(while) U {"else"} U {"while"}
     ->S(bloco) = { 'else', 'while', '}', P(instrucao) }
S(instrucao) = { '}' } U P(instrucao) U S(bloco)
     -> { '}',char, int, 'else', float, boolean, identificador, if, while, do, return, for, printf,scanf,*}


-------------------------------------------------------------------------------
Expressoes
-------------------------------------------------------------------------------	

                     -------------------Conjunto Primeiro---------------

  ok P(atribuicao) = P(variavel)
    ->P(atribuicao)= { '*' } U { 'identificador' }
  ok P<incremento> = { 'identificador' , "++", "--" }
  ok P(variavel) = { '*' } U { 'identificador' }
  ok P<expressao> = P<cast>
  ok P<logica_e> = P<cast>
  ok P<igualdade> = P<cast>
  ok P<relacional> = P<cast>
  ok P<op_igualdade> = {"==" , "!=" }
  ok P<op_relacional> = {"<" , "<=" , ">" , ">="}
  ok P<exp_aritmetica>= P<cast>
  ok P<op_adicao> = {"+" , "-"}
  ok P<multiplicacao> = P<cast>
  ok P<op_multiplicacao> = {"*" , "/" }
  ok P(cast) = { ( } U P(unario_prefixa)
 *      -> P(cast) = {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
  ok P(op_incremento) = { '++', '--' }
  ok P(op_unario) = { '&', '*' }
  ok P(unario_prefixa) = P(unario_posfixa) U P(op_incremento) U P(op_unario)
         ->P(unario_prefixa)= {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
  ok P<unario_posfixa>  =  P<elemento> U identificador
        -> P<unario_posfixa> = {identificador, "(", numeroInteiro , numeroFlutuante , charconst}
  ok P <elemento>  = P<primario> U "("
        -> P<elemento> = {"(", numeroInteiro , numeroFlutuante , charconst}
  ok P <elementos_gerais>  = P<op_incremento> U P<elemento_variavel>  U P<elemento_args>
        -> {'++', '--'} U {e, "[" , "." U "->""} U "("
  ok P <elemento_variavel>  = e, "[" ,  P <elemento_struct>
        -> P <elemento_variavel> = {e, "[" , "." U "->"}
  ok P <elemento_args>  = "("
  ok P <elemento_var>  = identificador
  ok P <elemento_struct>  = "." U "->"
 ok  P <primario> ::= {numeroInteiro , numeroFlutuante , charconst}

  
                          -------------------Conjunto Seguinte--------------

 ok S<atribuicao> = { ";",  ")"}
 ok S(incremento) = {";" }
 ok S(variavel) = {"="}
 ok S<expressao> = {";", ",", "}" ")"} U S<args_chamada> U S<atribuicao_var> U S<atribuicao>
    ->  S<expressao> = {";", ",", "}" ")"}
 ok S<logica_e> = P<logica_e> U S<expressao>
    -> S<logica_e> = {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
 ok S<igualdade> = {&&} U S<logica_e>
 ok S<relacional>  =  P<op_igualdade> U S<igualdade>
    ->S<relacional>  = {"==" , "!=" } U {&&} U {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
ok S<op_igualdade> = P<relacional>
ok S<op_relacional> = P<exp_aritmetica>
ok S<exp_aritmetica>=  P<op_relacional> U S<relacional>
    -> S<exp_aritmetica>= {"<" , "<=" , ">" , ">="} U {"==" , "!=" } U {&&} U {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
ok S<op_adicao> = P<multiplicacao>
ok S<multiplicacao> = P<op_adicao> U S<exp_aritmetica>
    ->S<multiplicacao> = {"+" , "-"} U {"<" , "<=" , ">" , ">="} U {"==" , "!=" } U {&&} U {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
ok S<op_multiplicacao> = P<cast>
ok S(cast) = P<op_multiplicacao> U S<multiplicacao> U S<cast>
    ->  S(cast) = P<cast> U {"+" , "-"} U {"<" , "<=" , ">" , ">="} U {"==" , "!=" } U {&&} U {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
ok S(op_incremento) = {identificador} U S<incremento> S<elementos_gerais>
ok S(op_unario) = { identificador }
ok S(unario_prefixa) = S(cast)
ok S<unario_posfixa>   = S<unario_prefixa>
ok S<elemento>  = S<unario_posfixa>
ok S<elementos_gerais>   = S<unario_posfixa>
    -> S<elementos_gerais> = P<cast> U {"+" , "-"} U {"<" , "<=" , ">" , ">="} U {"==" , "!=" } U {&&} U {'{'} U {identificador, "(", numeroInteiro , numeroFlutuante , charconst, '++', '--', '&', '*'}
                        U {";", ",", "}" ")"}
ok S<elemento_variavel>  = S<elementos_gerais>
ok S<elemento_args>  = S<elementos_gerais>
ok S<elemento_var>   = S<variavel>
ok S<elemento_struct>   = P<elemento_struct>   U S<elemento_variavel>-e  U S<elemento_var>
ok S<primario> = S<elemento>
------------------------------------------------------------------------------
 */

